Network object cache engine

ABSTRACT

The invention provides a method and system for caching information objects transmitted using a computer network. A cache engine determines directly when and where to store those objects in a memory (such as RAM) and mass storage (such as one or more disk drives), so as to optimally write those objects to mass storage and later read them from mass storage, without having to maintain them persistently. The cache engine actively allocates those objects to memory or to disk, determines where on disk to store those objects, retrieves those objects in response to their network identifiers (such as their URLs), and determines which objects to remove from the cache so as to maintain sufficient operating space. The cache engine collects information to be written to disk in write episodes, so as to maximize efficiency when writing information to disk and so as to maximize efficiency when later reading that information from disk. The cache engine performs write episodes so as to atomically commit changes to disk during each write episode, so the cache engine does not fail in response to loss of power or storage, or other intermediate failure of portions of the cache. The cache engine also stores key system objects on each one of a plurality of disks, so as to maintain the cache holographic in the sense that loss of any subset of the disks merely decreases the amount of available cache. The cache engine also collects information to be deleted from disk in delete episodes, so as to maximize efficiency when deleting information from disk and so as to maximize efficiency when later writing to those areas having former deleted information. The cache engine responds to the addition or deletion of disks as the expansion or contraction of the amount of available cache.

CROSS REFERENCE TO RELATED APPLICATIONS

[0001] This application is a continuation of application Ser. No.09/093,533 filed Jun. 8, 1998, Attorney docket Number 101.1001.02, ofnon-provisional application Serial No. 60/048,986, filed Jun. 9, 1997,Attorney docket Number 101.1001.01, and of PCT application Serial NumberPCT/US98/11834 filed Jun. 9, 1998 Attorney docket No. 101.1001.03.

BACKGROUND OF THE INVENTION

[0002] 1. Field of the Invention

[0003] This invention relates to devices for caching objects transmittedusing a computer network.

[0004] 2. Related Art

[0005] In computer networks for transmitting information, informationproviders (sometimes called “servers”) are often called upon to transmitthe same or similar information to multiple recipients (sometimes called“clients”) or to the same recipient multiple times. This can result intransmitting the same or similar information multiple times, which cantax the communication structure of the network and the resources of theserver, and cause clients to suffer from relatively long response tines.This problem is especially acute in several situations: (a) where aparticular server is, or suddenly becomes, relatively popular; (b) wherethe information from a particular server is routinely distributed to arelatively large number of clients; (c) where the information from theparticular server is relatively time-critical; and (d) where thecommunication path between the server and its clients, or between theclients and the network, is relatively slow.

[0006] One known method is to provide a device (such as a generalpurpose processor operating under software control) which acts as aproxy, receiving requests for information from one or more clients,obtaining that information from one or more servers, and transmittingthat information to the clients in place of the servers. When the proxyhas previously obtained the information from one or more servers, it candeliver that information to the client without having to repeat therequest to the server. While this method achieves the goal of reducingtraffic in the network and load on the server, it has the drawback thatsignificant overhead is required by the local operating system and thelocal file system or file server of the proxy. This adds to the expenseof operating the network and slows down the communication path betweenthe server and the client.

[0007] There are several sources of delay, caused primarily by theproxy's surrendering control of its storage to its local operatingsystem and local file system: (a) the proxy is unable to organize theinformation from the server in its mass storage for most rapid access;and (b) the proxy is unable to delete old network objects received fromthe servers and store new network objects received from the servers in amanner which optimizes access to mass storage. In addition to the addedexpense and delay, the proxy's surrendering control of its storagerestricts functionality of the proxy's use of its storage: (a) it isdifficult or impossible to add to or subtract from storage allocated tothe proxy while the proxy is operating; and (b) the proxy and its localfile system cannot recover from loss of any part of its storage withoutusing an expensive redundant storage technique, such as a RAID storagesystem.

[0008] Accordingly, it would be desirable to provide a method and systemfor caching information transmitted using a computer network, which isnot subject to additional delay or restricted functionality from havingto use a local operating system and local file system or file server.This advantage is achieved in an embodiment of the invention in which acache engine coupled to the network provides a cache of transmittedobjects, which it stores in memory and mass storage by taking directcontrol of when and where to store those objects in mass storage. Thecache engine may store those objects holographically so as to continueoperation smoothly and recover gracefully from additions to, failuresof, or removals from, its mass storage.

SUMMARY OF THE INVENTION

[0009] The invention provides a method and system for cachinginformation objects transmitted using a computer network. In theinvention, a cache engine determines directly when and where to storethose objects in a memory (such as RAM) and mass storage (such as one ormore disk drives), so as to optimally write those objects to massstorage and later read them from mass storage, without having tomaintain them persistently. The cache engine actively allocates thoseobjects to memory or to disk, determines where on disk to store thoseobjects, retrieves those objects in response to their networkidentifiers (such as their URLs), and determines which objects to removefrom the cache so as to maintain appropriate free space.

[0010] In a preferred embodiment, the cache engine collects informationto be written to disk in write episodes, so as to maximize efficiencywhen writing information to disk and so as to maximize efficiency whenlater reading that information from disk. The cache engine performswrite episodes so as to atomically commit changes to disk during eachwrite episode, so the cache engine does not fail in response to loss ofpower or storage, or other intermediate failure of portions of thecache. The cache engine stores key system objects on each one of aplurality of disks, so as to maintain the cache holographic in the sensethat loss of any subset of the disks merely decreases the amount ofavailable cache. The cache engine selects information to be deleted fromdisk in delete episodes, so as to maximize efficiency when deletinginformation from disk and so as to maximize efficiency when laterwriting new information to those areas of disk. The cache engineresponds to the addition or deletion of disks as the expansion orcontraction of the amount of available cache.

BRIEF DESCRIPTION OF THE DRAWINGS

[0011]FIG. 1 shows a block diagram of a network object cache engine in acomputer network.

[0012]FIG. 2 shows a block diagram of a data structure for maintainingstorage blocks for a set of cached network objects.

[0013]FIG. 3 shows a block diagram of data structures for cachingnetwork objects.

[0014]FIG. 4 shows a block diagram of a set of original and modifiedblocks.

[0015]FIG. 5 shows a flow diagram of a method for atomic writing ofmodified blocks to a single disk drive.

[0016]FIG. 6 shows a block diagram of a set of pointers and regions onmass storage.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

[0017] In the following description, a preferred embodiment of theinvention is described with regard to preferred process steps and datastructures. Those skilled in the art would recognize after perusal ofthis application that embodiments of the invention can be implementedusing general purpose processors and storage devices, special purposeprocessors and storage devices, or other circuits adapted to particularprocess steps and data structures described herein, and thatimplementation of the process steps and data structures described hereinwould not require undue experimentation or further invention.

[0018] ///

Caching Network Objects

[0019]FIG. 1 shows a block diagram of a network object cache engine in acomputer network.

[0020] A cache engine 100 is coupled to a computer network 110, so thatthe cache engine 100 can receive messages from a set of devices 111 alsocoupled to the network 110.

[0021] In a preferred embodiment, the network 110 includes a pluralityof such devices 111, interconnected using a communication medium 112.For example, where the network 110 includes a LAN (local area network),the communication medium 112 may comprise ethernet cabling, fiber opticcoupling, or other media. The network 110 preferably includes a networkof networks, sometimes called an “internet” or an “intranet.”

[0022] In a preferred embodiment, the devices 111 coupled to the network110 communicate with the cache engine 100 using one or more protocolsfor communication, such as HTTP (hypertext transfer protocol) or one ofits variants, FTP (file transfer protocol), or other protocols.

[0023] The cache engine 100 includes a processor 101 and a cache 102. Ina preferred embodiment, the processor 101 comprises a general purposeprocessor operating under software control to perform the methodsdescribed herein and to construct and use the data structures describedherein; as used herein, when the cache engine 100 performs particulartasks or maintains particular data structures that reference includescondign operation by the processor 101 under control of softwaremaintained in a program and data memory 103.

[0024] The cache 102 includes the program and data memory 103 and a massstorage 104. In a preferred embodiment, the mass storage 104 includes aplurality of disk drives such as magnetic disk drives, but mayalternatively include optical or magneto-optical disk drives. As usedherein, references to “disk” and “disk drives” refer to the mass storage104 and its individual drives, even if the mass storage 104 and itsindividual drives do not include physical disk-shaped elements. Thecache engine 100 is coupled to the network 110 and can receive andtransmit a set of protocol messages 113 according to the one or moreprotocols with which the devices 111 communicate with the cache engine100.

[0025] The cache engine 100 maintains a set of network objects 114 inthe cache 102. The cache engine 100 receives protocol messages 113 froma set of “client” devices 111 to request network objects 114 to beretrieved from a set of “server” devices 111. In response thereto, thecache engine 100 issues protocol messages 113 to request those networkobjects 114 from one or more server devices 111, receives those networkobjects 114 and stores them in the cache 102, and transmits thosenetwork objects 114 to the requesting client devices 111.

[0026] As used herein, the terms “client” and “server” refer to arelationship between the client or server and the cache engine 100, notnecessarily to particular physical devices 111. As used herein, one“client device” 111 or one “server device” 111 can comprise any of thefollowing: (a) a single physical device 111 executing software whichbears a client or server relationship to the cache engine 100; (b) aportion of a physical device 111, such as a software process or set ofsoftware processes executing on one hardware device 111, which portionof the physical device 111 bears a client or server relationship to thecache engine 100; or (c) a plurality of physical devices 111, orportions thereof, cooperating to form a logical entity which bears aclient or server relationship to the cache engine 100. The phrases“client device” and “server device” refer to such logical entities andnot necessarily to particular individual physical devices 111.

[0027] The cache engine 100 preserves the network objects 114 in thecache 102, and reuses those network objects 114 by continuing to servethem to client devices 111 which request them. When the cache 102becomes sufficiently full, the cache engine 100 removes network objects114 from the cache 102. For example, the cache engine 100 can removeobjects as described herein in the section “Removing Objects fromCache.”

[0028] In a preferred embodiment, the cache engine 100 uses the memory103 as a cache for those network objects 114 maintained using the massstorage 104, while using the combined memory 103 and mass storage 104 asthe cache 102 for those network objects 114 available on the network110.

[0029] The cache 102 is not a file storage system, and network objects114 which are stored in the cache 102 may be removed automatically fromthe cache 102 at any time by the cache engine 100. All network objects114 and all other data maintained by the cache 102 is transient, exceptfor a very small number of system objects which are required foroperation, and those system objects are redundantly maintained on themass storage 104 so as preserve those system objects against possibleloss of a part of the mass storage 104 (such as loss of one or more diskdrives). Thus the cache engine 100 need not guarantee that networkobjects 114 which are stored in the cache 102 will be available at anyparticular time after they are stored, and failure or even intentionalremoval of portions of the cache 102 (such as portions of the massstorage 104) cannot cause failure of the cache engine 100. Similarly,recovery or intentional addition of additional mass storage 104 (such as“hot swapping” of disk drives) is smoothly integrated into the cache 102without interruption of operation of the cache engine 100.

[0030] Moreover, the cache engine 100 operates exclusively to performthe operation of caching the network objects 114. There is no separate“operating system,” no user, and there are no user application programswhich execute independently on the processor 101. Within the memory 103,there are no separate memory spaces for “user” and “operating system.”The cache engine 100 itself maintains the cache 102 of the networkobjects 114 and selects the network objects 114 for retention in thecache 102 or removal from the cache 102, operating so as to (1) localizewriting the network objects 114 to the mass storage 104, (2) localizedeletion of the network objects 114 from the mass storage 104, and (3)efficiently replace the network objects 114 in the cache 102 with newnetwork objects 114. In a preferred embodiment, the cache engine 100performs these operations efficiently while operating the cache 102relatively filled with network objects 114.

[0031] In a preferred embodiment, the cache engine 100 maintainsstatistics regarding access to the cache 102. These statistics caninclude the following:

[0032] a set of hit rates for the cache 102, including (1) a hit ratefor network objects 114 found in the cache 102 versus those which mustbe retrieved from server devices 111, and (2) a hit rate for networkobjects 114 found in the memory 103 versus those which must be retrievedfrom the mass storage 104;

[0033] a set of statistics for operations on the memory 103, including(1) the number of network objects 114 which are maintained in the memory103, and (2) the fraction of memory 103 which is devoted to cachingnetwork objects 114 versus storing system objects or unallocated; and

[0034] a set of statistics for operations on the mass storage 104,including (1) the number of read operations from the mass storage 104,(2) the number of write operations to the mass storage 104, includingthe number of “write episodes” as described herein, and (3) the fractionof the mass storage 104 which is devoted to caching network objects 114versus storing system objects or unallocated.

[0035] The cache engine 100 can also maintain statistics which arecombinations or variants of the above.

Using the Cache Engine

[0036] There are numerous circumstances in which the cache engine 100can provide improved performance or additional functionality in thenetwork 110. For example, the cache engine 100 can be used as a proxycache (whether to provide a firewall, to provide a cache for clientdevices 111 coupled to a local area network, or otherwise), as a reverseproxy cache, as a cache for requests made by users of a single ISP, as acache for “push” protocols, or as an accelerator or server cache.

[0037] The cache engine 100 provides the client devices 111 withrelatively quicker access to network objects 114 otherwise availabledirectly from the server devices 111. Typically the client devices 111request those network objects 114 from the cache engine 100, whicheither transmits them to the client devices 111 from the cache 102 orobtains them from the server devices 111 and then transmits them to theclient devices 111.

[0038] The cache engine 100 can exercise more intelligence andproactivity than simply waiting for documents to be requested by theclient devices 111:

[0039] The cache engine 100 can be configured preloaded with selectednetwork objects 114 which are expected to be requested by the clientdevices 111. For example, certain network objects 114 are known to becommonly requested by client devices 111 throughout the network 110known as the internet; these network objects 114 can be preloaded in thecache engine 100 upon manufacture. These network objects 114 couldinclude home pages for well-known companies (such as Netscape) andwell-known search engines (such as Digital's “Alta Vista”).

[0040] The cache engine 100 can periodically request network objects 114responsive to a set of statistics regarding commonly requested networkobjects 114. For example, information regarding commonly requestednetwork objects 114 can be maintained on a server device 111; the cacheengine 100 can request this information from the server device 111 andperiodically request those network objects 114 for storage in the cache102. In a preferred embodiment, the cache engine 100 can perform thisoperation periodically when client devices 111 are not actively usingthe cache engine 100, such as relatively unloaded times in the latenight or early morning.

[0041] The cache engine 100 can periodically request network objects 114responsive to a set of user preferences at the client devices 111. Forexample, the cache engine 100 can receive (either upon request orotherwise) a set of bookmarks from the client devices 111 and canrequest those network objects 114 from the server devices 111. In apreferred embodiment, the cache engine 100 can request those networkobjects 114 which have changed in a selected time period such as oneday.

[0042] The cache engine 100 can provide a mirror site to one or moreserver devices 111, by periodically, or upon request, receiving networkobjects 114 from the server devices 111 to be delivered by the serverdevice 111 to client devices 111 which have changed in a selected timeperiod such as one day.

[0043] The cache engine 100 can provide an accelerator for one or moreserver devices 111, by receiving requests to the server devices 111which are distributed among a plurality of cache engines 100. Each cacheengine 100 maintains its cache 102 with network objects 114 to bedelivered by the server device 111 to client devices 111. Service by theserver device 111 is thus accelerated, because each cache engine 100 canrespond to some of the load of requests for information, while limitingthe number of requests for information which are passed through and mustbe handled by the server device 111 itself.

[0044] The cache engine 100 can provide a first type of push protocolassist to one or more server devices 111, by transmitting networkobjects 114 to one or more client devices 111 or proxy caches using apush protocol. For example, when the server devices 111 provide anetwork broadcast service, the cache engine 100 can receive networkobjects 114 from the server devices 111 to be broadcast to a subset ofthe network 110 and can independently broadcast those network objects114.

[0045] The cache engine 100 can provide a second type of push protocolassist to one or more server devices 111, by allowing those serverdevices 111 to broadcast network objects 114 to a plurality of cacheengines 100. Each cache engine 100 can make the broadcast networkobjects 114 available to client devices 111 which request those networkobjects 114 from the cache engine 100 as if the cache engine 100 werethe server device 111 for those network objects 114.

[0046] The network objects 114 can include data, such as HTML pages,text, graphics, photographs, audio, video; programs, such as Java orActiveX applets or applications; or other types of network objects, suchas push protocol objects. The cache engine 100 can record frames ofstreaming audio or streaming video information in the cache 102, fordelayed use by a plurality of client devices 111. Some types of knownnetwork objects 114 are not cached, such as CGI output or items markednoncachable by the server device 111.

[0047] In a preferred embodiment, the cache engine 100 can gleanknowledge about the client devices 111 from the protocol messages 113 orby other means, such as interrogating routing devices in the network110, and can react in response to that information to provide differingnetwork objects 114 to differing client devices 111. For example, thecache engine 100 can select server devices 111 for proximity or contentin response to information about client devices 111, as follows:

[0048] The cache engine 100 can select a particular server device 111for rapid response, such as for network routing proximity or forspreading service load over a plurality of server devices 111.

[0049] The cache engine 100 can select content at the server device 111in response to information about the client device 111, such astailoring the language of the response (such as serving pages in theEnglish language or the French language), or such as tailoring localinformation (such as advertising, news, or weather). In a preferredembodiment, local information such as advertising can be retrieved froma local server device 111 which supplies advertising for insertion intopages to be served to local client devices 111.

The Cache

[0050]FIG. 2 shows a block diagram of a data structure for maintainingstorage blocks for a set of cached network objects.

[0051] The cache 102 includes a set of blocks 200, each of whichcomprises 4096 bytes in a preferred embodiment, and each of which can bestored in the memory 103 or on the mass storage 104. In alternativeembodiments, each of the blocks 200 can comprise a size other than 4096bytes, and may be responsive to an amount of available memory 103 ormass storage 104.

[0052] Each of the blocks 200 can comprise either a data block 200,which includes data, that is, information not used by the cache engine100 but maintained for the client devices 111, or control information,that is, information used by the cache engine 100 and not used by theclient devices 111.

[0053] The blocks 200 are organized into a set of objects 210, each ofwhich comprises an object descriptor 211, a set of data blocks 200, anda set of block pointers 212 referencing the data blocks 200 from theobject descriptor 211. The object descriptor 211 comprises a separatecontrol block 200. Where the block pointers 212 will not fit into asingle control block 200, or for other types of relatively largerobjects 210, the object descriptor 211 can reference a set of indirectblocks 216, each of which references inferior indirect blocks 216 ordata blocks 200. Each indirect block 216 comprises a separate controlblock 200. Relatively smaller objects 210 do not require indirect blocks216.

[0054] The block pointers 212 each comprise a pointer value 215comprising a single 32-bit word and indicating the location of the block200 on the mass storage 104, such as a physical disk block address.

[0055] In an alternative embodiment, the block pointers 212 eachcomprise a first bit 213 indicating whether the referenced block 200 isstored in the memory 103 or the mass storage 104, a second bit 214indicating whether the referenced block 200 is a control block 200(comprising control information) or a data block 200 (comprising datafor network objects 114), and the pointer value 215 comprises a 30-bitvalue indicating the location of the block 200. In such alternativeembodiments, when the block 200 is stored in the memory 103, the pointervalue 215 indicates a byte address in the memory 103; when the block isstored on the mass storage 104, the pointer value 215 indicates aphysical disk block address on the mass storage 104.

[0056] In a preferred embodiment, the objects 210 are each referenced bya root object 220, which is maintained redundantly in a plurality of(preferably two) copies of a root block 221 on each disk drive of themass storage 104. In a preferred embodiment, there is one root object220 for each disk drive of the mass storage 104. Thus, each disk driveof the mass storage 104 has a separate root object 210, which ismaintained using two copies of its root block 221. Each disk drive'sroot object 220 references each current object 210 for that disk drive.

[0057] In a preferred embodiment, one copy of the root block 221 ismaintained in each of physical disk blocks 2 and 3 of each of the diskdrives of the mass storage 104. When the root block 221 for that diskdrive is written to the mass storage 104, it is first written to thephysical disk block 2, and then identically written to the physical diskblock 3. When the cache engine 100 is started or restarted, the rootblock 221 is read from the physical disk block 2. If this read operationis successful, it is then identically rewritten to the physical diskblock 3; however, if this read operation is unsuccessful, the root block221 is instead read from the physical disk block 3, and then identicallyrewritten to the physical disk block 2.

[0058] In a preferred embodiment, the cache engine 100 also storescertain system objects 210 redundantly on each disk drive on the massstorage 104, so as to maintain the cache 102 holographic in the sensethat loss of any subset of the disk drives merely decreases the amountof available cache. Thus, each such system object 210 is referenced bythe root object 220 for its disk drive and is maintained using twocopies of its object descriptor 211. These system objects 210 which aremaintained redundantly include the root object 220, a blockmap object210, and a hash table 350 (FIG. 3), each as described herein, as well asother system objects, such as objects 210 for collected statistics,documentation, and program code.

[0059] A subset of the blocks 200 are maintained in the memory 103, soas to use the memory 103 as a cache for the mass storage 104 (just asthe memory 103 and the mass storage 104 collectively act as the cache102 for network objects 114). The blocks 200 maintained in the memory103 are referenced by a set of block handles 230, which are alsomaintained in the memory 103.

[0060] Each of the block handles 230 includes a forward handle pointer232, a backward handle pointer 233, a reference counter 234, a blockaddress 235, a buffer pointer 236, and a set of flags 237.

[0061] The forward handle pointer 232 and the backward handle pointer233 reference other block handles 230 in a doubly-linked list of blockhandles 230.

[0062] The reference counter 234 maintains a count of references to theblock 200 by processes of the cache engine 100. The reference counter234 is updated when a block handle 230 for the block 200 is claimed orreleased by a process for the cache engine 100. When the referencecounter 234 reaches zero, there are no references to the block 200, andit is placed on a free list of available blocks 200 after having beenwritten to disk, if it has been modified, in the next write episode.

[0063] The block address 235 has the same format as the block pointer212. The buffer pointer 236 references a buffer used for the block 200.The flags 237 record additional information about the block 200.

[0064] In one embodiment, the block handles 230 are also threaded usinga set of 2Q pointers 238 and a 2Q reference counter 239, using the “2Q”technique, as further described in “2Q: A Low Overhead High PerformanceBuffer Management Replacement Algorithm,” by Theodore Johnson and DennisShasha, hereby incorporated by reference as if fully set forth herein.

How Network Objects are Cached

[0065]FIG. 3 shows a block diagram of data structures for cachingnetwork objects.

[0066] The cache engine 100 receives protocol requests from the network110. In a preferred embodiment, each protocol request uses the HTTPprotocol (or a variant such as SHTTP), and each HTTP request includes aURL (uniform resource locator) 310, which identifies a network object114 in the network 110. In a preferred embodiment, each URL 310identifies the server device 111 for the network object 114 and thelocation of the network object 114 on that server device 111.

[0067] In alternative embodiments, the cache engine 100 may use otherprotocols besides HTTP or its variants, and the cache engine 100 may beresponsive to one or more other identifiers for network objects 114besides its URL 310. Accordingly, as used herein, the term “URL” refersgenerally to any type of identifier which is capable of identifying, orassisting in identifying, a particular network object 114.

[0068] The URL 310 includes a host identifier, which identifies theserver device 111 at which the network object 114 is located, and adocument identifier, which identifies the location at which the networkobject 114 is located at the server device 111. In a preferredembodiment, the host identifier comprises a character string name forthe server device 111, which can be resolved to an IP (internetprotocol) address. However, in alternative embodiments, the hostidentifier may comprise the IP address for the server device 111, ratherthan the character string name for the server device 111.

[0069] The cache engine 100 includes a hash function 320 whichassociates the URL 310 with a hash signature 330, which indexes a hashbucket 340 in a hash table 350 in the cache 102. In a preferredembodiment, the hash table 350 comprises a set of hash tables 350, onefor each disk drive, each of which references those network objects 114which are stored in the cache 102 on that disk drive of the mass storage104. Each such hash table 350 has its own object descriptor 211;collectively the hash tables 350 form a single logical hash table.

[0070] In a preferred embodiment, the hash signature 330 comprises a32-bit unsigned integer value which is determined responsive to the URL310, and which is expected to be relatively uniformly distributed overthe range of all possible 32-bit unsigned integer values. In a preferredembodiment, the URL 310 is also associated with a 64-bit URL signaturewhich is also an unsigned integer value, determined responsive to theURL 310, and which is expected to be relatively uniformly distributedover the range of all possible 64-bit unsigned integer values; whencomparing URLs 310, the URL signatures are compared first, and only ifthey are equal are the URLs 310 themselves compared. In a preferredembodiment, the URL 310 is also converted to a canonical form prior todetermining the hash signature 330 or the URL signature, such as byconverting all alphabetic characters therein into a single case (lowercase or upper case). In a preferred embodiment, each non-null hashbucket 340 comprises one data block 200.

[0071] Because the hash table 350 associates the URL 310 directly withthe hash bucket 340 in the hash table 350, storage of the networkobjects 114 in the cache 102 is not hierarchical; each of the networkobjects 114 can be referenced and accessed from the cache 102 withinorder of constant time, such as less than about two disk read accesstimes. Moreover, there is no special requirement that the networkobjects 114 in the cache 102 must have unique names; when networkobjects 114 have identical names (such as when they are old and newversions of the same network object 114), the hash table 350 simplypoints to the same hash bucket 340 for both of them.

[0072] When there are both old and new versions of the same networkobject 114, the cache engine 100 resolves new references by the URL 310only to the new version of the network object 114. Those client devices111 which are already accessing the old version of the network object114 when the new version of the network object 114 is stored in thecache 102 will continue to access the old version of the network object114. However, subsequent accesses to that network object 114, even bythe same client device 111, using the URL 310 will be resolved by thecache engine 100 to the new version of the network object 114. The oldversion of the network object 114 is deleted as soon as possible whenall client devices 111 are done using it.

[0073] The cache 102 differs from a file system also in that the clientdevice 111 has no control over storage of the network objects 114 in thecache 102, including (1) the name space at the cache 102 for storage ofthe network objects 114, (2) the ability to name or rename the networkobjects 114, (3) whether the network objects 114 are removed from thecache 102 at any time, and (4) whether the network objects 114 are evenstored in the cache 102 at all.

[0074] In a preferred embodiment, the cache engine 100 uses the memory103 and the mass storage 104 (preferably a plurality of magnetic diskdrives) to cache the network objects 114 so as to maintain in the cache102 those network objects 114 most likely to be required by the clientdevice 111. However, in alternative embodiments, the cache engine 100may enforce selected administrative requirements in addition tomaintaining network objects 114 most likely to be used by the clientdevice 111, such as preferring or proscribing certain classes of networkobjects 114 or certain classes of client devices 111 or server devices111, whether at all times or at selected times of day and selected days.

[0075] The cache engine 100 uses the hash function 320 and the hashtable 350 to identify an object 210 (and thus one or more data blocks200) associated with the URL 310 (and thus associated with the networkobject 114). The cache engine 100 operates on the object 210 to retrievefrom the cache 102 the network object 114 requested by the HTTP request,and to deliver that network object 114 to the client device 111. Thecache engine 100 maintains the cache 102 using the memory 103 and themass storage 104 so that whether the object 210 is in the cache 102, andif in the cache 102, whether the object 210 is in the memory 103 or onthe mass storage 104 is transparent to the client device 111 (exceptpossibly for different time delays in retrieving the object 210 from thememory 103 or from the mass storage 104).

[0076] As described herein in the section “Writing to Disk,” the cacheengine 100 writes blocks 200 (and objects 210 comprising those blocks200) from the memory 103 to the mass storage 104 on occasion, so as tomaintain those blocks 200 in the memory 103 which are most frequentlyaccessed.

[0077] As described herein, when writing blocks 200 from the memory 103to the mass storage 104, the cache engine 100 controls where the blocks200 are written onto the mass storage 104 (such as determining ontowhich disk drive for the mass storage 104 and which location on thatdisk drive), and when the blocks 200 are written onto the mass storage104 (such as determining at which times it is advantageous to write dataonto the mass storage 104). The cache engine 100 attempts to optimizethe times and locations when and where the blocks 200 are written todisk, so as to minimize time and space required to write to and readfrom disk.

[0078] The hash table 350 is a system object 210, and similar to othersystem objects 210, includes an object descriptor 211, zero or moreindirect blocks 216, and zero or more data blocks 200. Because the hashtable 350 is expected to be used relatively frequently, its indirectblocks 216 are expected to all be maintained in the memory 103, althoughfor a relatively large hash table 350 some of its data blocks 200 willbe maintained on the mass storage 104. In a preferred embodiment, thehash table 350 is distributed over the plurality of disk drives for themass storage 104, and the portion of the hash table 350 for each diskdrive is referenced in the root object 220 for that disk drive.

[0079] Each hash signature 330 is indexed into the hash table 350 usingthe hash signature 330 modulo the number of hash buckets 340 in the hashtable 350. Each hash bucket 340 comprises one block 200. Each hashbucket 340 includes zero or more hash entries 360; each hash entry 360includes a reference to the object 210 at the hash entry 360 (comprisinga pointer to the object descriptor 211 for that object 210).

[0080] The hash bucket 340 includes a secondary hash table, having aplurality of chains of secondary hash table entries (such as, forexample, 32 such chains). The hash signature 330 is used to select oneof the chains so as to search for the hash entry 360 associated with theURL 310.

[0081] In an alternative embodiment, the hash entries 360 are maintainedwithin the hash bucket 340 in an ordered list by a secondary hash value,with null entries possibly interspersed (when the associated networkobjects 114 have been deleted or otherwise removed from the hash table350); the secondary hash value is also determined in response to thehash signature 330, such as by computing the hash signature 330 modulo aselected value such as 2**32. If there are multiple hash entries 360with the same secondary hash value, the cache engine 100 examines theobject descriptor 211 associated with each one of the multiple hashentries 360 for the URL 310 of the correct network object 114 associatedwith the URL 310 having the associated hash signature 330.

[0082] In a preferred embodiment, each hash bucket 340 has a selectedsize which is sufficient to hold at least 1.5 to 2 times the number ofexpected hash entries 360 if the hash entries 360 were perfectlyuniformly distributed (this selected size is preferably exactly one datablock 200). If a hash entry 360 is assigned to a hash bucket 340 whichis full, one of the network objects 114 already associated with the hashbucket 340, along with its associated hash entry 360, is deleted fromthe hash bucket 340 and from the cache 102 to make room for the new hashentry 360.

[0083] In a preferred embodiment, there can be a plurality of differentoperational policies for selecting just which objects 210 are deletable.

[0084] ///

Mass Storage with Multiple Disk Drives

[0085] The cache engine 100 maintains a DSD (disk set descriptor) object210 for each disk drive currently or recently present on the massstorage 104, which includes a data structure describing that disk drive.The cache engine 100 also maintains a DS (disk set) object 210, whichreferences all of the DSD objects 210, and which is maintainedredundantly on one or more of the disk drives for the mass storage 104.Thus, the DS object 210 is maintained redundant on the mass storage 104on a plurality of disk drives (preferably all of them), with each diskdrive's information being maintained on that disk drive in the DSDobject 210.

[0086] Each DSD object 210 includes at least the following information:(1) the number of disk drives; (2) the collective total size of all diskdrives; (3) for each disk drive—the individual size of that disk drive,an identifier for that disk drive, and a index into an array of all thedisk drives; and (4) for each disk drive—the range of hash signatures330 which are maintained on that disk drive. Also, the range of hashsignatures 330 which are maintained on each disk drive is maintained ina separate system object 210 which maps each hash signature 330 to aparticular disk drive. In a preferred embodiment, sizes are expressed asmultiples of a selected value such as 1 megabyte.

[0087] The hash entries 360 are distributed over the plurality of diskdrives in proportion to the size of each disk drive, rounded to aninteger number of hash entries 360.

[0088] When a disk drive is added, removed, or replaced, the cacheengine 100 creates or modifies an associated DSD object 210, and updatesthe DS object 210. This operation proceeds in like manner as updating adata block 200; thus, any control blocks 200 which reference the DSobject 210 or one of the DSD objects 210 are also updated, and theupdate is atomically committed to the mass storage 104 with the nextwrite episode. (Updates to the DS object 210 are atomically committedfor each disk drive, one at a time.) Thus, the mass storage 104 can bedynamically updated, including changing the identity or number of diskdrives, while the cache engine 100 continues to operate, and the onlyeffect on the cache engine 100 is to alter its perception of the amountof mass storage 104 which is available for the cache 102.

Writing to Disk

[0089] The cache engine 100 implements a “delayed write” technique, inwhich the objects 210 which are written into the cache 102 (includingobjects 210 which are new versions of old objects 210 already present inthe cache 102) are written first into the memory 103, and only laterwritten out to the mass storage 104. Unlike file systems which usedelayed write techniques, there is no need to provide a non-volatile RAMor a UPS (uninterruptable power supply) and an associated orderlyshutdown procedure, because the cache engine 100 makes no guarantee ofpersistence for the network objects 114 in the cache 102. For example,if a particular network object 114 is lost from the cache 102, thatnetwork object 114 can typically be reacquired from its associatedserver device 111.

[0090] However, the delayed write technique operates to maintainconsistency of the cache 102, by not overwriting either control blocks200 or data blocks 200 (except for the root block 221). Instead,modified blocks 200 are written to the mass storage 104, substituted forthe original blocks 200, and the original blocks 200 are freed, all inan atomic operation called a “write episode.” If a write episode isinterrupted or otherwise fails, the entire write episode failsatomically and the original blocks 200 remain valid.

[0091] A modified data block 200 is created when the underlying data forthe original data block 200 is modified (or when new underlying data,such as for a new network object 114, is stored in a new data block200). A modified control block 200 is created when one of the originalblocks 200 (original data block 200 or original control block 200)referenced by the original control block 200 is replaced with a modifiedblock 200 (modified data block 200, new data block 200, or modifiedcontrol block 200); the modified control block 200 references themodified block 200 rather than the original block 200.

[0092] Each write episode is structured so as to optimize both theoperation of writing blocks 200 to the mass storage 104 and lateroperations of reading those blocks 200 from the mass storage 104. Thefollowing techniques are used to achieve the read and write optimizationgoals:

[0093] modified blocks 200 to be written are collected and written, whenpossible, into sequential tracks of one of the disk drives used for themass storage 104;

[0094] indirect blocks 216 are written to storage blocks which are closeto and before those data blocks 200 which they reference, so as toenable reading the referenced data blocks 200 in the same read operationwhenever possible;

[0095] sequentially related data blocks 200 are written to sequentialfree storage blocks (if possible, contiguous free storage blocks) on oneof the disk drives used for the mass storage 104, so as to enablereading the related data blocks 200 in the same read operation wheneverpossible;

[0096] blocks 200 (control blocks 200 or data blocks 200) to be writtenare collected together for their associated objects 210 and orderedwithin each object 210 by relative address, so as to enable readingblocks 200 for a particular object 210 in the same read operationwhenever possible.

[0097]FIG. 4 shows a block diagram of a set of original and modifiedblocks.

[0098]FIG. 5 shows a flow diagram of a method for atomic writing ofmodified blocks to a single disk drive.

[0099] A tree structure 400 (FIG. 4) of blocks 200 includes the originalcontrol blocks 200 and the original data blocks 200, which have beenalready written to the mass storage 104 and referenced by the rootobject 220. Some or all of these original blocks 200 can be held in thememory 103 for use.

[0100] A method 500 (FIG. 5) includes a set of flow points to be noted,and steps to be executed, by the cache engine 100.

[0101] At a flow point 510, the modified data blocks 200 and new datablocks 200 are held in the memory 103 and have not yet been written todisk.

[0102] Because no data block 200 is rewritten in place, each originalcontrol block 200 which references a modified data block 200 (and eachoriginal control block 200 which references a modified control block200) must be replaced with a modified control block 200, all the way upthe tree structure 400 to the root object 200.

[0103] At a step 521, for each modified data block 200, a free storageblock on the mass storage 104 is allocated for recording the modifieddata block 200. The blockmap object 210 is altered to reflect theallocation of the storage block for the modified data block 200 andfreeing of the storage block for the original data block 200.

[0104] The blockmap object 210 maintains information about which storageblocks on the mass storage 104 are allocated and have data storedtherein, and which storage blocks are free and eligible for use. Thecache engine 100 searches the blockmap object 210 for a free storageblock, maintaining a write pointer 250 into the blockmap object 210 soas to perform the search in a round-robin manner. Thus, when the writepointer 250 advances past the end of the blockmap object 210, it iswrapped around to the beginning of the blockmap object 210. The writepointer 250 is maintained in the root object 220 so that the searchcontinues in a round-robin manner even after a failure and restart ofthe cache 102.

[0105] To maintain consistency of the cache 102 in the event of afailure, a free storage block 200 cannot be considered free (andtherefore used) if it is still referenced, even if indirectly, by theroot object 220. Accordingly, those blocks 200 which are freed prior toatomic commitment of the root object 220 are not considered free untilthe root object 220 is atomically written to disk.

[0106] At a step 522, for each original control block 200 whichreferences an original block 200 which is to be modified in this writeepisode, a modified control block 200 is generated. In like manner asthe step 521, a free storage block on the mass storage 104 is allocatedfor recording the modified control block 200. In like manner as the step521, the blockmap object 210 is modified to reflect the allocation ofthe storage block for the modified control block 200 and freeing of thestorage block for the original control block 200.

[0107] The step 522 is repeated for each level of the tree structure 400up to the root object 220.

[0108] At a step 523, the operations of the step 521 and the step 522are repeated for those blocks 200 of the blockmap object 210 which werealtered.

[0109] At a step 524, the modified data blocks 200 and modified controlblocks 200 (including the blockmap object 210) are written to theirallocated storage blocks on the mass storage 104.

[0110] At a step 525, the root object 220 is rewritten in place on themass storage 104.

[0111] At a flow point 530, the root object 220 has been rewritten inplace, all changes to the tree structure 400 have thus been atomicallycommitted; the modified blocks 200 have become part of the treestructure 400 and the original blocks 200 which were replaced withmodified blocks 200 have become freed and eligible for reuse. Themodified blockmap object 210 is not atomically committed until the rootobject 220 has been rewritten in place, so storage blocks which areindicated as allocated or free are not so indicated until the writeepisode has been atomically committed at the flow point 530.

[0112] When the modified blocks 200 are actually allocated to storageblocks and written to those storage blocks on the mass storage 104, theyare written in the following manner:

[0113] the tree structure 400 is traversed in a depth-first top-downmanner, so as to ensure that modified control blocks 200 are written ina sequence of storage blocks before the modified data blocks 200 theyreference;

[0114] at each modified control block 200, the referenced modified datablocks 200 are traversed in a depth-first top-down manner, so as toensure that the referenced modified data blocks 200 are clusteredtogether in a sequence of storage blocks after the modified controlblock 200 which references them.

[0115] This technique helps to ensure that when reading control blocks200, the data blocks 200 they reference are read-ahead wheneverpossible, so as to minimize the number of operations required to readthe control blocks 200 and the data blocks 200 from the mass storage104.

[0116] The cache engine 100 determines when to perform a write episode,in response to the condition of the memory 103 (including the number ofmodified blocks 200 in the memory 103), the condition of the massstorage 104 (including the number of free storage blocks available onthe mass storage 104), and the condition of the cache 102 (including thehit rate of network objects 114 in the cache 102).

[0117] In a preferred embodiment, write episodes using the method 500are performed upon either of the following conditions:

[0118] when a certain time (such as 10 seconds) have elapsed since theprevious write episode; or

[0119] when modified blocks comprise too large a proportion of memory.

[0120] Write episodes using the method 500 can also be performed uponeither of the following conditions:

[0121] the number of modified blocks 200 in the memory 103 is near thenumber of available free storage blocks on the mass storage 104 minusthe number of storage blocks needed for the blockmap object 210; or

[0122] the fraction of modified blocks 200 in the memory 103 is near themiss rate of network objects 114 in the cache 102.

[0123] However, the number of free blocks 200 on the mass storage 104 isnormally much larger than the number of blocks 200 to be written duringthe write episode.

[0124] Each object 210 has an associated “access time,” which indicateswhen that object 210 was last written or read. However, it is notdesirable to update the access time on disk for each object 210 wheneverthat object 210 is read, as this would produce a set of modified controlblocks 200 (which must be written to disk during the next write episode)whenever any object 210 is read.

[0125] Accordingly, a volatile information table is maintained whichrecords volatile information about objects 210, including access timesfor objects 210 which have been read, and number of accesses for thoseobjects 210. When an object 210 is read, its access time is updated onlyin the volatile information table, rather than in the object descriptor211 for the object 210 itself. The volatile information table ismaintained in the memory 103 and is not written to disk.

[0126] In a preferred embodiment, network objects 114 can continue to beread while write episodes using the method 500 are being performed, evenfor those network objects 114 which include modified data blocks 200,because the modified data blocks 200 continue to be maintained in thememory 103 while the write episodes are performed, whether or not theyare actually successfully written to the mass storage 104.

Removing Objects from Cache

[0127]FIG. 6 shows a block diagram of a set of pointers and regions onmass storage.

[0128] A set of storage blocks on each disk drive of the mass storage104 is represented by a circular map 600, having indexes from zero to amaximum value Nmax. In the figure, indexes increase in acounterclockwise direction, wrapping around from the end to thebeginning of each disk drive modulo the maximum value Nmax.

[0129] A DT (delete table) object 210 is maintained which includes anentry for each deletable object 210. Each time one of the hash buckets340 in the hash table 350 is accessed, a reference is inserted into theDT object 210 for each object 210 which is referenced by one of the hashentries 360 in that hash bucket 340 and which qualifies as deletable.

[0130] In alternative embodiments, an objectmap object 210 is maintainedwhich includes an entry for each of the blockmap entries in the blockmapobject 210. In such alternatives, each entry in the objectmap object 210is either empty, which indicates that the corresponding block 200 doesnot comprise an object descriptor 211 or non-empty, which indicates thatthe corresponding block 200 comprises an object descriptor 211, andfurther includes information to determine whether the correspondingobject 210 can be deleted. Each non-empty entry in the objectmap object210 includes at least a hit rate, a load time, a time to live value anda hash signature 330 for indexing into the hash table 350.

[0131] The cache engine 100 searches the blockmap object 210 for adeletable object 210 (an object 210 referenced by the DT object 210),maintaining a delete pointer 260 into the blockmap object 210, similarto the write pointer 250, so as to perform the search in a round-robinmanner. Thus, similar to the write pointer 250, when the delete pointer260 advances past the end of the blockmap object 210, it is wrappedaround to the beginning of the blockmap object 210. Also similar to thewrite pointer 250, the delete pointer 260 is maintained in the rootobject 220 so that the search continues in a round-robin manner evenafter a failure and restart of the cache 102.

[0132] The write pointer 250 and the delete pointer 260 for each diskdrive in the mass storage 104 each comprise an index into the map 600.

[0133] In a preferred embodiment, the delete pointer 260 is maintainedat least a selected minimum distance d0 601 ahead of the write pointer250, but not so far ahead as to wrap around again past the write pointer250, so as to select a delete region 610 of each disk drive for deletingdeletable objects 210 which is near to a write region 620 used forwriting modified and new objects 210. The write region 620 is at leastthe size specified by the minimum distance d0 601. Although there is nospecific requirement for a size of the delete region 610, it ispreferred that the delete region 610 is several times (preferably aboutfive times) the size of the write region 620. The cache engine 100 thusprovides that nearly all writing to disk occurs in a relatively smallpart of each disk drive. This allows faster operation of the massstorage 104 because a set of disk heads for the mass storage 104 mustmove only relatively a small distance during each write episode.

[0134] Because the cache engine 100 attempts to maintain a relativelyfixed distance relationship between the write pointer 250 and the deletepointer 260, write episodes and delete episodes will occur relativelyfrequently. In a preferred embodiment, the cache engine 100 alternatesbetween write episodes and delete episodes, so that each delete episodeoperates to make space on disk for a later write episode (the nextsucceeding write episode writes the blockmap object 210 to disk, showingthe blocks 200 to be deleted; the write episode after that is able touse the newly free blocks 200) and each write episode operates toconsume free space on disk and require a later delete episode.

[0135] A collection region 630 is selected near to and ahead of thedelete region 610, so as to select objects 210 for deletion. A size ofthe collection region 630 is selected so that, in an time estimated forthe write pointer 250 to progress through the collection region 630(this should take several write episodes), nearly all hash entries 360will have been accessed through normal operation of the cache engine100. Thus, because each hash entry 360 includes information sufficientto determine whether its associated object 210 is deletable, nearly allobjects 210 will be assessed for deletion in the several write episodesneeded for the write region 620 to move through the collection region630.

[0136] Objects 210 which have been assessed for deletion are placed onan deletion list, sorted according to eligibility for deletion. In apreferred embodiment, objects 210 are assessed for deletion according toone of these criteria:

[0137] If an object 210 is explicitly selected for deletion by the cacheengine 100 due to operation of the HTTP protocol (or a variant thereof,such as SHTTP), the object 210 is immediately placed at the head of thedeletion list.

[0138] If a new object 210 with the same name is created, the old object210 is placed at the head of the deletion list as soon as all referencesto the old object 210 are released (that is, no processes on the cacheengine 100 reference the old object 210 any longer).

[0139] If an object 210 has expired, it is immediately placed at thehead of the deletion list.

[0140] If a first object 210 has an older access time than a secondobject 210, the first object 210 is selected as more eligible fordeletion than the second object 210, and is thus sorted into thedeletion list ahead of the second object 210.

[0141] A fraction of objects 210 on the deletion list chosen due to thelast two of these criteria (that is, due to expiration or older accesstime), preferably one-third of the objects 210 on the deletion list, areselected for deletion.

[0142] After each write episode, the collection region 630 is advancedby an expected size of the next write region 620. In a preferredembodiment, the expected size of the next write region 620 is estimatedby averaging the size of the write region 620 for the past several(preferably seven) write episodes. Those objects 210 which were on thedeletion list before advancing the delete region 610 and which are inthe delete region 610 afterward are scheduled for deletion; theseobjects are selected individually and deleted in the next delete episode(in a preferred embodiment, the next delete episode is immediately aftercompletion of the write episode).

[0143] In a preferred embodiment, write episodes and delete episodes foreach disk drive on the mass storage 104 are independent, so there areseparate deletion regions 610, write regions 620, and collection regions630 for each disk drive on the mass storage 104.

ALTERNATIVE EMBODIMENTS

[0144] Although preferred embodiments are disclosed herein, manyvariations are possible which remain within the concept, scope, andspirit of the invention, and these variations would become clear tothose skilled in the art after perusal of this application.

1. A system for objects on a network, said system including a receivercoupled to said network; a cache engine operative to record a objectfrom said network on mass storage; wherein said cache engine is capableof selecting times to record said object, selecting locations to recordsaid object, storing said object holographically so as to continueoperation after loss of a portion of said mass storage, or minimizingtime needed to write to said mass storage.